Power amplifiers (PA) are essential components in wireless applications that boost the power of the analog signal being transmitted. However, these are power hungry devices and must be operated close to saturation to maximize their efficiency. This causes problems as PAs are inherently nonlinear near saturation, leading to unacceptable error vector magnitude (EVM) and adjacent channel leakage ratio (ACLR) performance. Digital predistortion (DPD) is a popular technique to linearize the input-output characteristics of PAs.
FIG. 1 illustrates a conventional DPD datapath portion of a circuit. In the figure, DPD datapath portion 100 includes three primary blocks: an address calculator portion 102, a lookup table (LUT) portion 104, and an interpolation unit (optional) 106. DPD datapath portion 100 also includes a multiplier 108.
In operation, address calculator portion 102 receives an input signal 110 and determines the appropriate indices m and n of the LUT portion 104. The basic operation of address calculator portion 102 will now be described with reference to FIG. 2.
FIG. 2 illustrates a data set 200 of address calculator portion 102. Address calculator portion 102 may be a register having number of addresses that may vary depending on the needs of the system. For example, suppose that a system is designed to receive a signal having an amplitude that varies between −3.0 mA and +3.0 mA. In such a system, if address calculator portion 102 included a 4-bit register, then data set 200 would include 16 data entries between −3.0 mA and +3.0 mA, wherein the data entries have a 0.375 mA resolution. On the other hand, if address calculator portion 102 included an 8-bit register, then data set 200 would include 256 data entries between −3.0 mA and +3.0 mA, wherein the data entries have a 0.023 mA resolution. Clearly, a register having a smaller number of bits may occupy a relatively small amount of physical space, but will be able to address a relatively small number of data entries. On the other hand, larger register may occupy a relatively large amount of physical space, but will be able to address a relatively large number of data entries. Of course address calculator portion may have any known system of data entries, a non-limiting example of which includes non-uniform data entries.
Data set 200 in FIG. 2 includes a set of entries from 1 to a predetermined number Φ.
Presume at a time t, input signal 110 inputs a value x to address calculator portion 102. Further, presume that the value x is not stored within any of the entries from 1 to Φ, but lies between the values m and n stored in entries 202 and 203 of data set 200. Address calculator portion 102 outputs the values m and n stored in entries 202 and 203 as signals 112 and 114. If, for the sake of discussion, the value x exactly matches an entry within data set 200, then address calculator portion 102 may output the matching entry as signal 112, and may output a zero value for signal 114. In any event, it is statistically likely that the input value will not be identical to an entry within data entry set 200.
Once, address calculator portion 102 provides values m and n corresponding to an input value, LUT portion 104 will generate corresponding gain values. Operation of an example LUT portion 104 will be discussed with reference to FIG. 3.
FIG. 3 illustrates a data structure that may be stored within LUT portion 104. LUT portion 104 may include a plurality of registers that make up lookup tables 300 and 310. Lookup table 300 corresponds to entries of input m, whereas lookup table 310 corresponds to entries of input n. In other examples, LUT portion 104 may be structured in any known manner, a non-limiting example of which includes a single lookup table having entries for input m and input n.
Lookup table 300 includes a first column of data entries 302 that correspond to input m values from address calculator portion 102, and a second column of corresponding data entries 304 of gain values Gm. For each data entry of first column of data entries 302 there is a corresponding output gain entry value in second column of corresponding data entries 304 of gain values Gm. For example, with additional reference to FIG. 1, for a value m passed via signal 112 from address calculator portion 102, there is a corresponding data entry 306 in first column of data entries 302. Accordingly, the gain Gm that corresponds to m value data entry 306 is data entry 308 in second column of corresponding data entries 304 of gain values Gm.
Similarly, lookup table 310 includes a first column of data entries 312 that correspond to input n values from address calculator portion 102, and a second column of corresponding data entries 314 of gain values Gn. For each data entry of first column of data entries 312 there is a corresponding output gain entry value in second column of corresponding data entries 314 of gain values Gn. For example, with additional reference to FIG. 1, for a value n passed via signal 114 from address calculator portion 102, there is a corresponding data entry 316 in first column of data entries 312. Accordingly, the gain Gn that corresponds to n value data entry 316 is data entry 318 in second column of corresponding data entries 314 of gain values Gn.
Returning to FIG. 1, LUT portion 104 outputs a first gain value G1, corresponding to data entry 308 of FIG. 3, via signal 116, and outputs a second gain value G2, corresponding to data entry 318 of FIG. 3, via signal 118 to interpolation unit 106.
Interpolation unit 106 may not be needed all the time. As described above, if a value x of input 110 at time t exactly matches an entry within data set 200, as illustrated in FIG. 2, then no interpolation is needed. Specifically, in such a case, a predetermined gain value will be provided by LUT portion 104 and a specific gain will be output via signal 120 from interpolation unit 106. However, if a value x of input 110 at time t is between data entry 202 and 203, as illustrated in FIG. 2, then LUT portion 104 outputs gain values G1 and G2 via signal 116 and 118. Interpolation unit 106 determines an exact gain that lies between gain values G1 and G2. Operation of an example interpolation unit 106 will be now be discussed with reference to FIG. 4.
FIG. 4 is a graph of a gain function of a conventional interpolation unit 106, wherein a value x of input 110 at time t is on the x-axis, and a corresponding output gain value G(x) is on the y-axis. The graph explains how conventional interpolation unit 106 may interpolate a gain for an input value located between two predetermined input values. In FIG. 4, point 402 corresponds to gain Gn for input n, whereas point 404 corresponds to gain Gm for input m. Interpolation unit 106 generates an interpolate function ƒ(λ) 406 based on an interpolation factor λ 124 provided by address calculator portion 102. For an input value x at time t from input signal 110, wherein x is between m and n as discussed above, conventional interpolation unit 106 interpolates a corresponding gain Gx at point 412 based on the interpolation function ƒ(λ). This gain, Gx, is the final gain G that interpolation unit 106 outputs to multiplier 108 via interpolator output signal 120, when the value of x does not match the value of either one of m or n.
However, with a conventional interpolation scheme, interpolation unit 106 may use any one of a plurality of interpolate functions, e.g., interpolation functions 408 and 410, to determine an output gain for an input x at time t. As illustrated in the figure, if a different interpolation function is used, then a different corresponding gain will be calculated. For example, if interpolation function 408 were used to determine an output gain for input value x at time t, as opposed to interpolation function ƒ(λ) 406, then the point 414 on interpolation function 408 would provide an output gain of Gx′, which in this case is larger than Gx. This inconsistency in gains as a result of having a plurality of possible interpolation functions is a drawback of conventional interpolation techniques and will be discussed further below.
Returning back to FIG. 1, multiplier 108 multiplies the final gain G, included in interpolator output signal 120, with input signal 110 and outputs a predistorted signal 126 to a PA (not shown).
The goal of predistortion is to provide a linear response through a cascade of the DPD and the PA. However, due to numerous reasons such as manufacturing variations, age, and temperature, the PA's nonlinear characteristics can vary over time and also from PA to PA. Hence online adaptation of the DPD to compensate for the prevalent PA nonlinearity is essential. Two popular conventional learning architectures that compensate for the prevalent PA nonlinearity include a Direct Learning Architecture (DLA) and an Indirect Learning Architecture (ILA). These two conventional learning architectures will be discussed below.
FIG. 5 illustrates a block diagram of a conventional direct learning architecture (DLA). Circuit 500 includes a DPD datapath portion 502, a PA 504, a gain inverter 506 and a comparator 508. DPD datapath portion 502 corresponds to DPD datapath portion 100 in FIG. 1.
In operation, an input signal x[n] 510 is fed into DPD datapath portion 502. DPD datapath portion 502 then outputs a predistorted input signal 512 to PA 504. Since PA 504 itself does not have a good linearity characteristic for high amplitude inputs, the output amplified signal y[n] 514 may not be linear. Therefore, a conventional DLA trains the pre-inverse of the nonlinearity of PA 504 over the entire swing of input signal x[n] 510. Output amplified signal y[n] 514 is multiplied with the reciprocal of amplifier gain G by gain inverter 506, to become a feedback signal 516. Feedback signal 516 is sent to comparator 508 for comparison with input signal x[n] 510. Based on the comparison, comparator 508 outputs an error signal e[n] 518 to DPD datapath portion 502. DPD datapath portion 502 adjusts predistorted input signal 512 based on the error signal e[n] 518.
However, the conventional DLA has various implementation issues since the adaptation takes place in the forward path. Referring to FIG. 5, gain inverter 506 directly samples PA's output 514 and feeds back the inverse of signal 514 to comparator 508. Such training that occurs in the transmission path will be problematic. To overcome this drawback, the conventional DLA could use a model in which training occurs outside the forward path and the trained DPD parameters can be copied over to the forward path at predetermined intervals. A modified DLA model is shown in FIG. 6 below.
FIG. 6 illustrates a conventional modified DLA. Circuit 600 includes DPD datapath portion 502 and PA 504. In addition, circuit 600 includes a DPD adaptation portion 602, a PA model portion 604, an inverter 606 and a comparator 608.
In operation, DPD datapath portion 502 receives input signal x[n] 510 and outputs predistorted input signal 512 to PA 504. A difference between the conventional modified DLA of FIG. 6 and the conventional DLA of FIG. 5 is that in modified DLA, the training occurs outside the forward path.
Referring to FIG. 6, input signal x[n] 510 is also sent to DPD adaptation portion 602, which outputs a predistorted input signal 610 to PA model portion 604. Note that it is PA model portion 604 that provides feedback, i.e., signal ŷ[n] 612, to inverter 606 in modified DLA 600, as opposed to PA 504 as described above with reference to FIG. 5. Inverter 606 multiples signal ŷ[n] 612 with reciprocal of amplifier gain G and provides the result, a feedback signal 614, to comparator 608. Comparator 608 compares input signal x[n] 510 with feedback signal 614, and generates an error signal e[n] 616.
Error signal e[n] 616 is fed into DPD adaptation portion 602 to determine the adjustment to the DPD datapath portion 502 to modify predistorted input signal 512 in order to linearize the gain of PA 504. More specifically, as will be described in more detail below, a trainable LUT portion (not shown) within DPD adaptation portion 602 may update an LUT portion (not shown) within DPD datapath portion 502 through a signal 618 periodically, based on a predetermined time interval. As a consequence, predistorted input signal 512 will be updated periodically in order keep an output signal y[n] 514, from PA 504, linear. The mathematical analysis of this modified model is shown below, with reference to FIGS. 1 and 6.
If H(x) is the gain provided by LUT portion 104 for an input x, F(•) is a nonlinear gain of PA 504, and G is the desired linear gain of PA 504, then DLA 600 adapts such thatH(x)F(xH(x))=G  (1)
Equation (1) mathematically explains how the desired linear gain G of PA 504 is constructed. If PA 504 is nonlinear, its output gain F(xH(x)) is also not linear. Therefore, the gain H(x) provided by LUT 104 will compensate the nonlinear gain of PA 504 to a desired linear gain G.
Using a more general system representation with F(•) representing the operator of PA 504 and H(•) representing the operator of DPD datapath portion 502, equation (1) can be written asF(H(x))=G·x  (2)Equation (2) shows that DPD adaptation portion 602 provides predistorted input to PA 504 so that PA can generate a desired linear output, which is G·x.
The drawback of the modified DLA is that an accurate PA model must always be maintained, requiring additional memory and training, which further increases the cost of the system.
Indirect learning architecture (ILA) is another conventional training architecture that avoids the drawback of DLA. A conventional ILA will now be described with reference to FIGS. 7 and 8.
FIG. 7 illustrates a block diagram for a conventional ILA. In the figure, circuit 700 includes a DPD datapath portion 702, a PA 704, a gain inverter 706, a comparator 708 and a DPD adaptation portion 710.
In operation, DPD datapath portion 702 receives an input signal x[n] 712 and outputs a predistorted input signal w[n] 714 to PA 704. PA 704 provides an output amplified signal y[n] 716 to gain inverter 706. Gain inverter multiplies output amplified signal y[n] 716 with the reciprocal of amplifier gain G, to become a feedback signal z[n] 718, which is provided to DPD adaptation portion 710.
Contrary to the DLA described above with respect to FIGS. 5 and 6, in the ILA, DPD Datapath portion 702 is trained outside the forward path without the need for a PA model.
In FIG. 7, predistorted input signal w[n] 714 is additionally sent to comparator 708. DPD adaptation portion 710 outputs a signal ŵ[n] 724, based on feedback signal z[n] 718, to comparator 708. Comparator 708 compares predistorted input signal w[n] 714 with signal ŵ[n] 724 and generates an error signal e[n] 720.
Error signal e[n] 720 is then fed back to DPD adaptation portion 710, which will update the adjustment to predistorted input signal w[n] 714 in order to linearize the gain of PA 704. More specifically, a trainable LUT portion (not shown) within DPD adaptation portion 710 may update an LUT portion (not shown) within DPD datapath portion 702 through a signal 722 periodically, based on a predetermined time interval. As a consequence, predistorted input signal w[n] 714 will be updated periodically in order keep an output signal 714, from PA 704, linear.
In FIG. 7, although DPD adaptation portion 710 is the pre-inverse of PA 704, circuit 700 trains DPD adaptation portion 710 as the post-inverse of PA 704. Assuming that predistorted input signal w[n] 714 and signal ŵ[n] 724 are identical, the trained parameters of DPD adaptation portion 710 are copied over to DPD datapath portion 702 at predetermined intervals. The mathematical analysis of this modified model is shown below, with reference to FIGS. 1 and 7.
If H(x) is the gain provided by LUT 104 for an input x, F(•) is the nonlinear gain of PA 704, {tilde over (H)}(•) is the gain provided by LUT 104 being trained, and G is the desired linear gain of PA 704, then the ILA 700 adapts such that
                                          F            ⁡                          (                              xH                ⁡                                  (                  x                  )                                            )                                ·                                    H              ~                        ⁡                          (                                                                    xH                    ⁡                                          (                      x                      )                                                        ·                                      F                    ⁡                                          (                                              xH                        ⁡                                                  (                          x                          )                                                                    )                                                                      G                            )                                      =        G                            (        3        )            
In equation (3), xH(x) is the input of PA 704 and F(xH(x)) is the output gain of PA 704. F(xH(x)) is not linear due to the nonlinearity of PA 704.
            H      ~        ⁡          (                                    xH            ⁡                          (              x              )                                ·                      F            ⁡                          (                              xH                ⁡                                  (                  x                  )                                            )                                      G            )        ,which is the gain provided by trained LUT 104 of DPD adaptation portion 710, is used to compensate for the nonlinearity of the output gain F(xH(x)) of PA 704 and results in a desired linear gain G.
Using a more general system representation with F(•) representing the operator of PA 704, H(•) representing the operator of DPD datapath portion 702 and {tilde over (H)}(•) representing the operator of DPD adaptation portion 710, equation (3) can be written as
                                          H            ~                    ⁡                      (                                          F                ⁡                                  (                                      H                    ⁡                                          (                      x                      )                                                        )                                            G                        )                          =                  H          ⁡                      (            x            )                                              (        4        )            
In equation (4),
      H    ~    ⁡      (                  F        ⁡                  (                      H            ⁡                          (              x              )                                )                    G        )  represents the output of DPD adaptation portion 710, H(x) represents the output of DPD datapath portion 702. Equation (4) implies that outputs of DPD adaptation portion 710 and DPD datapath portion 702 are equal when the system is stable.
The primary drawback of ILA is that the DPD parameters are trained over the PA output values. Due to the gain compression characteristics of the PA, the output signal swing could be smaller than that of the input signal. Hence some entries in the LUT, particularly the higher amplitude entries, might never be trained. Such behavior is seen in FIGS. 8A-8C.
FIG. 8A is a graph of a gain transfer characteristics of DPD datapath portion 702, wherein the x-axis represents the input to DPD datapath portion 702 and the y-axis represents the output from DPD datapath portion 702. In FIG. 8A, a gain transfer characteristics 802 is curved having a first portion 804 over the majority of the input portion of the graph that is curved slightly upward in a convex fashion and having a second portion 806 at the upper input portion of the graph that is linear after a discontinuity. As discussed above, second portion 806 is distortion caused by the drawback of ILA in which the LUT is difficult to train for higher amplitude entries.
FIG. 8B is a graph of a gain transfer characteristics of PA 704, wherein the x-axis represents the input to PA 704 and the y-axis represents the output from PA 704. In FIG. 8B, a gain transfer characteristics 808 is a curve that is curved slightly downward in a concave fashion. The non-linearity of gain transfer characteristics 808 illustrates the non-linearity of the power amplifier 704.
FIG. 8C is a graph of a gain transfer characteristics of DPD datapath portion 702 and PA 704, wherein the x-axis represents the input to DPD datapath portion 702 and the y-axis represents the output from PA 704. In FIG. 8C, a gain transfer characteristics 810 is curve having a first portion 812 over the majority of the input portion of the graph that is linear and having a second portion 814 at the upper input portion of the graph that is curved downward in a concave fashion after a discontinuity. FIG. 8C illustrates that DPD datapath portion 702 may not be trained over entire input signal swing in ILA.
Both DLA and ILA discussed above use a standard least mean squares (LMS) algorithm when interpolating between two indices in a LUT in order to provide a linearized gain to a PA. However, the traditional LMS algorithm has some significant limitations on efficiency and accuracy, as explained below.
FIG. 9 illustrates an exploded view of DPD adaptation portion 710 of FIG. 7, in combination with comparator 708, that is used to train DPD datapath portion 702 by interpolating between two indices in a LUT in order to provide a linearized gain to a PA. DPD adaptation portion 710 includes an address calculator portion 902, a trainable LUT portion 904, an interpolation unit 906 and a multiplier 908.
In ILA operation, address calculator portion 902 receives feedback signal z[n] 718 and determines the appropriate indices m and n of LUT portion 904. Address calculator portion 902 then outputs the indices information to LUT portion 904 through indices signals 916 and 918. LUT portion 904 provides the gains stored at the requested indices m and n. The outputs of LUT portion 904, G1 and G2, which are represented by signals 920 and 922 respectively, are sent to interpolation unit 906. Interpolation unit 906 then interpolates between the multiple gains based on the interpolation factor 924 and provides a signal 926 as a final gain G to multiplier 908. Multiplier 908 multiples the final gain G from signal 926 with feedback signal z[n] 718 and outputs signal ŵ[n] 724 to comparator 708. Comparator 708 compares signal ŵ[n] 724 with predistorted input signal w[n] 714 and generates error signal e[n] 720. Error signal e[n] 720 is used to modify indices within trainable LUT portion 904, i.e., train trainable LUT portion 904. Since signal ŵ[n] 724 continues to update and feed back to comparator 708, eventually error signal e[n] 720 approaches zero.
With additional reference to FIG. 7, periodically, the indices within trainable LUT portion 904 are copied to the LUT (not shown) within DPD datapath portion 702. As error signal e[n] 720 approaches zero, eventually the indices within trainable LUT portion 904 are copied to the LUT within DPD datapath portion 702. Accordingly, predistorted input signal w[n] 914 approaches a desired gain to a PA (not shown).
The standard LMS algorithm used with interpolated LUTs uses standard gradient descent techniques, which require interpolation between LUT entries. An error term is generated by comparing a reference signal with the amplified input and is used to train the LUT. This is mathematically explained below.e=w−Gy e=w−[Gm+λ(Gn−Gm)]y e=w−yGm+λ(w−yGn−w+yGm)  (5)Letem=w−Gmy en=w−Gny  (6)Substituting (6) into (5) yieldse=em+λ(en−em)e=(1−λ)em+λen  (7)Let a cost function C be defined to be minimized asC=e*e C=[(1−λ)em+λen]*[(1−λ)em+λen]C=(1−λ)2|em|2+2Re{λ(1−λ)em*en}+λ2|en|2  (8)Here, e* is the complex conjugate of complex number e. Therefore, C=0 implies e=0, but not em=en. In practice, it is nearly impossible to actually achieve C=0. However, gradient descent algorithms like LMS apply corrections to the adaptive parameters of the system, which in this case is simply the interpolated gain G, along the direction that minimizes the cost function C. For a given combination of {w, y} an infinite number of {Gm. Gn} pairs can result in the same interpolated gain G, leading to non unique solutions for {Gm. Gn}. This is shown FIG. 10.
FIG. 10 is a graph of a plurality of interpolated gain functions, wherein the x-axis is an input y and the y-axis is the associated gain G=w/y. In the figure, infinite {Gm, Gn} pairs result in the same interpolated gain G for a given y. Solid line 1002 represents the correct gain to be applied for varying inputs. However, for a particular input y, dashed lines 1004, 1006, 1008, 1010 and 1012 all intersect the same interpolated gain G. FIG. 10 illustrates that the standard LMS algorithm has the drawback of non-unique solutions. Consider the update equations below,
                              [                                                                      G                  m                                                                                                      G                  n                                                              ]                =                                            [                                                                                          G                      m                                                                                                                                  G                      n                                                                                  ]                        -                                          μ                2                            ⁢                              ∇                                  e                  *                                            ⁢                              e                ⁢                                                                  [                                                                                                    G                        m                                                                                                                                                G                        n                                                                                            ]                                              =                                                    [                                                                                                    G                        m                                                                                                                                                G                        n                                                                                            ]                            +                                                μ                  ⁡                                      [                                                                                                                        1                            -                            λ                                                                                                                                                λ                                                                                      ]                                                  ⁢                                  y                  *                                ⁢                                  e                  ⁢                                                                          [                                                                                                              G                          m                                                                                                                                                              G                          n                                                                                                      ]                                                      =                                          [                                                                                                    G                        m                                                                                                                                                G                        n                                                                                            ]                            +                              μ                ⁢                                                                  ⁢                                                      y                    *                                    ⁡                                      [                                                                                                                                                                                                                        (                                                                      1                                    -                                    λ                                                                    )                                                                2                                                            ⁢                                                              e                                m                                                                                      +                                                                                          λ                                ⁡                                                                  (                                                                      1                                    -                                    λ                                                                    )                                                                                            ⁢                                                              e                                n                                                                                                                                                                                                                                                                                                    λ                                2                                                            ⁢                                                              e                                n                                                                                      +                                                                                          λ                                ⁡                                                                  (                                                                      1                                    -                                    λ                                                                    )                                                                                            ⁢                                                              e                                m                                                                                                                                                                          ]                                                                                                          (        9        )            Here, ∇ is the gradient and μ is the step of gradient descent. Note that in equation (9), the direction of the correction term applied to both neighboring gain entries in the LUT is the same, regardless of the correctness of the individual entries. Only the scale factors are different.
The standard LMS algorithm used in conventional LUT based DPD datapath portion has the advantages of requiring computation of only a single error term and requiring only a single adaptation algorithm. However, the drawbacks of conventional a LUT implementation are more significant. First, it requires an interpolation block to determine an interpolated gain. Second, for a given combination of {w, y}, an infinite number of {Gm, Gn} pairs can result in the same interpolated gain G that minimizes the cost function. Finally, the direction of the correction applied to both {Gm, Gn} is the same, regardless of the correctness of each individual term. Such disadvantages limit both accuracy and cost of the system.
What is needed is a training architecture that combines the strengths of DLA and ILA but overcome the drawbacks of two traditional training architectures. The new training architecture should be able to provide improved linearization performance.